home *** CD-ROM | disk | FTP | other *** search
/ Sounds Terrific 2 / Sounds Terrific II (1996)(Weird Science)(Disc 1 of 2)[Amiga-PC].iso / archives / amiga / amichord.lha / AmiChord / src / grid.c < prev    next >
C/C++ Source or Header  |  1995-04-09  |  17KB  |  456 lines
  1. #include "chord.h"
  2.  
  3. struct chord_struct chordtab[MAX_CHORD];
  4. int nb_chord;
  5. int first_ptr = 0;
  6.  
  7. /* char known_chords[256][CHORD_NAME_SZ]; */
  8. struct kcs {
  9.     char chord_name[CHORD_NAME_SZ];
  10.     int displ;
  11.     int s1, s2, s3, s4, s5, s6;
  12. } known_chords[MAX_CHORD];
  13.  
  14. int nb_known_chord = 0;
  15.  
  16. extern int hpos, vpos;
  17. extern int grid_size;
  18. extern char mesg[MAXTOKEN];
  19.  
  20. do_init_grid_ps() {
  21.     printf("%% routines for the drawing of the chords\n");
  22.     printf("/grid { \n");
  23.     printf("        gsave currentpoint\n");
  24.     printf("        6 { 0 cagesizeX rlineto incr cagesize neg incr add rmoveto } repeat\n");
  25.     printf("        moveto\n");
  26.     printf("        5 { cagesize 0 rlineto 0 cagesize sub incr rmoveto } repeat\n");
  27.     printf("        1 setlinewidth stroke grestore\n");
  28.     printf("        gsave\n");
  29.     printf("        0 cagesizeX rmoveto cagesize 0 rlineto\n");
  30.     printf("        cagesize 30 div setlinewidth stroke\n");
  31.     printf("        grestore        \n");
  32.     printf("} def\n");
  33.     printf("\n");
  34.     printf("/dot {\n");
  35.     printf("        gsave\n");
  36.     printf("        /fret exch def /str exch def\n");
  37.     printf("        /x 5  fret abs sub incr mul half-incr sub def\n");
  38.     printf("        /y 6 str sub incr mul def\n");
  39.     printf("        y x rmoveto\n");
  40.     printf("        0 setgray\n");
  41.     printf("        fret -1 eq\n");
  42.     printf("          {\n");
  43.     printf("          0 incr rmoveto\n");
  44.     printf("          check neg  check neg rmoveto\n");
  45.     printf("          check check rlineto check check rlineto\n");
  46.     printf("          check neg check neg rmoveto check neg check rmoveto\n");
  47.     printf("          check check neg rlineto check check neg rlineto\n");
  48.     printf("          cagesize 50 div setlinewidth stroke\n");
  49.     printf("          }\n");
  50.     printf("          {  fret 0 ne\n");
  51.     printf("            { currentpoint dot-size 0 360 arc fill}\n");
  52.     printf("            { currentpoint\n");
  53.     printf("              check 0 360 newpath arc\n");
  54.     printf("              cagesize 50 div setlinewidth\n");
  55.     printf("            }\n");
  56.     printf("            ifelse \n");
  57.     printf("            stroke \n");
  58.     printf("          }\n");
  59.     printf("          ifelse\n");
  60.     printf("        grestore\n");
  61.     printf("} def   \n");
  62.     printf("\n");
  63.     printf("/dots {\n");
  64.     printf("        grid\n");
  65.     printf("        /fret-displ exch def\n");
  66.     printf("          1 1 6\n");
  67.     printf("          {\n");
  68.     printf("            /str exch def\n");
  69.     printf("            /fret exch def\n");
  70.     printf("            fret %d ne {str fret dot} if\n", FRET_NONE);
  71.     printf("          } for\n");
  72.     printf("\n");
  73.     printf("        fret-displ 1 ne\n");
  74.     printf("        {\n");
  75.     printf("          gsave\n");
  76.     printf("          0 cagesize 3 div sub cagesizeX incr sub rmoveto\n");
  77.     printf("          /char 1 string def fret-displ char cvs show grestore \n");
  78.     printf("        } if\n");
  79.     printf("\n");
  80.     printf("        /chord-name exch def\n");
  81.     printf("        gsave displ-font setfont\n");
  82.     printf("        0 cagesizeX cagesizeX 15 div add dot-size 3 mul add rmoveto\n");
  83.     printf("        chord-name stringwidth pop 2 div cagesize 2 div exch sub 0 rmoveto\n");
  84.     printf("        chord-name show chord-font setfont grestore\n");
  85.     printf("} def\n");
  86.     printf("\n");
  87.     printf("/cagesize %d def\n",grid_size);
  88.     printf("/incr cagesize 5 div def\n");
  89.     printf("/cagesizeX incr 4 mul def\n");
  90.     printf("/half-incr incr 2 div def\n");
  91.     printf("/dot-size cagesize 15 div def\n");
  92.     printf("/check cagesize 20 div def\n");
  93.     printf("\n");
  94.     printf("/chord-font /Times-Roman findfont cagesize 5 div scalefont def\n");
  95.     printf("/displ-font /Times-Roman findfont cagesize 3 div scalefont def\n");
  96.     printf("%% end of the routines for the drawing of the chords\n");
  97.     printf("\n");
  98. }
  99.  
  100. int add_to_chordtab (char *chord) {
  101.     int i, prev_i, n;
  102.  
  103.     i = first_ptr;
  104.     prev_i = -1;
  105.     while (1) {
  106.         if (nb_chord > 0 && i != -1) {
  107.             n = strcmp (chord, chordtab[i].chord_name);
  108.             if (n == 0)
  109.                 return (i);
  110.             else if (n > 0) {
  111.                 prev_i = i;
  112.                 i = chordtab[i].next_ptr;
  113.                 continue;
  114.             }
  115.         } strcpy (chordtab[nb_chord].chord_name, chord);
  116.         if (nb_chord != 0)
  117.             chordtab[nb_chord].next_ptr = i;
  118.         else
  119.             chordtab[nb_chord].next_ptr = -1;
  120.         if (prev_i != -1)
  121.             chordtab[prev_i].next_ptr = nb_chord;
  122.         if (i == first_ptr)
  123.             first_ptr = nb_chord;
  124.         if (nb_chord >= MAX_CHORD - 1) {
  125.             fprintf (stderr, "too many chords, bumping %s\n",
  126.                      chordtab[nb_chord - 1].chord_name);
  127.             return (nb_chord - 1);
  128.         } nb_chord++;
  129.  
  130.         fprintf (stderr, "dumping chordtab (start is %d)\n", first_ptr);
  131.         for (i = 0; i < nb_chord; i++)
  132.             fprintf (stderr, "       %d:     %10s -> %d\n",
  133.                      i, chordtab[i].chord_name, chordtab[i].next_ptr);
  134.         return (nb_chord - 1);
  135.     }
  136. }
  137.  
  138. moveto (int new_hpos, int new_vpos) {
  139.     if (new_hpos + grid_size + L_MARGIN > WIDTH) {
  140.         new_hpos = L_MARGIN;
  141.         new_vpos -= 2 * grid_size;
  142.     } if (new_vpos < BOTTOM) {
  143.         do_end_of_page ();
  144.         do_start_of_page ();
  145.         new_vpos = TOP - 2 * grid_size;
  146.     } printf ("%d %d moveto\n", new_hpos, new_vpos);
  147.     hpos = new_hpos;
  148.     vpos = new_vpos;
  149. }
  150.  
  151. draw_chords () {
  152.     int ptr, idx;
  153.  
  154.     moveto (WIDTH - grid_size - grid_size - L_MARGIN, vpos);
  155.  
  156.     ptr = first_ptr;
  157.     if (nb_chord != 0) {
  158.         while (ptr != -1) {
  159.             moveto (hpos + 2 * grid_size, vpos);
  160.  
  161.             if ((idx = is_chord_known (chordtab[ptr].chord_name)) == -1) {
  162.                 sprintf (mesg, "chord \'%s\' has never been defined",
  163.                          chordtab[ptr].chord_name);
  164.                 error (mesg);
  165.  
  166.                 printf ("(%s) 0 0 0 0 0 0 1 dots\n",
  167.                         chordtab[ptr].chord_name);
  168.             }
  169.             else
  170.                 printf ("(%s) %d %d %d %d %d %d %d dots\n",
  171.                         known_chords[idx].chord_name,
  172.                         known_chords[idx].s1,
  173.                         known_chords[idx].s2,
  174.                         known_chords[idx].s3,
  175.                         known_chords[idx].s4,
  176.                         known_chords[idx].s5,
  177.                         known_chords[idx].s6,
  178.                         known_chords[idx].displ);
  179.             ptr = chordtab[ptr].next_ptr;
  180.         }
  181.     }
  182. }
  183.  
  184. do_define_chord () {
  185.     int dot_array[6];
  186.     char *chord_name;
  187.     char *temp_str;
  188.     int fret_displ;
  189.     int n;
  190.     int hardtoplay = 0;
  191.  
  192.     for (n = 0; n < 6; n++)
  193.         dot_array[n] = 0;
  194.  
  195.     chord_name = (char *) strtok (NULL, DELIM_STR);
  196.     if (chord_name == NULL) {
  197.         error ("syntax error in chord definition: no chord name");
  198.         return (0);
  199.     } temp_str = (char *) strtok (NULL, DELIM_STR);
  200.     if (temp_str == NULL) {
  201.         error ("syntax error in chord definition: no base fret position");
  202.         return (0);
  203.     } fret_displ = atoi (temp_str);
  204.  
  205.     for (n = 5; n >= 0; n--) {
  206.         temp_str = (char *) strtok (NULL, DELIM_STR);
  207.  
  208.         if (temp_str != NULL) {
  209.             if (!strcmp (temp_str, FRET_NONE_STR))
  210.                 dot_array[n] = FRET_NONE;
  211.             else if (tolower (temp_str[0]) == tolower (FRET_X_STR))
  212.                 dot_array[n] = FRET_X;
  213.             else {
  214.                 dot_array[n] = atoi (temp_str);
  215.                 if (dot_array[n] < 0)
  216.                     dot_array[n] = FRET_NONE;
  217.             } hardtoplay = hardtoplay || (dot_array[n] > LONG_FINGERS);
  218.         }
  219.         else {
  220.             error ("syntax error in chord definition : too few arguments");
  221.             return (0);
  222.         }
  223.     } if (hardtoplay) {
  224.         sprintf (mesg,
  225.                  "Warning: You'll need long fingers to play \"%s\" this way!", chord_name);
  226.         error (mesg);
  227.     } learn_chord (chord_name,
  228.                    dot_array[0], dot_array[1], dot_array[2],
  229.                    dot_array[3], dot_array[4], dot_array[5],
  230.                    fret_displ);
  231. }
  232.  
  233. learn_chord (char *chord, int s1, int s2, int s3, int s4, int s5, int s6, int displ) {
  234.     int i, not_found;
  235.  
  236.     not_found = TRUE;
  237.     for (i = 0; i < nb_known_chord && not_found; i++) {
  238.         not_found = strcmp (chord, known_chords[i].chord_name);
  239.     };
  240.  
  241.     if (not_found) {
  242.         if (nb_known_chord >= MAX_CHORD - 1) {
  243.             fprintf (stderr, "too many chords, can't learn %s\n", chord);
  244.             return (0);
  245.         } nb_known_chord++;
  246.     }
  247.     else {
  248.         i--;
  249.     } strcpy (known_chords[i].chord_name, chord);
  250.     known_chords[i].displ = displ;
  251.     known_chords[i].s1 = s1;
  252.     known_chords[i].s2 = s2;
  253.     known_chords[i].s3 = s3;
  254.     known_chords[i].s4 = s4;
  255.     known_chords[i].s5 = s5;
  256.     known_chords[i].s6 = s6;
  257.  
  258. }
  259.  
  260. init_known_chords () {
  261.     nb_known_chord = 0;
  262.  
  263. #define N FRET_NONE
  264. #define X FRET_X
  265.     learn_chord ("Ab", 1, 3, 3, 2, 1, 1, 4);
  266.     learn_chord ("Abm", 1, 3, 3, 1, 1, 1, 4);   /* G#m is preferred */
  267.     learn_chord ("Ab7", N, N, 1, 1, 1, 2, 1);
  268.     learn_chord ("Abm7", N, N, 1, 1, 1, 1, 4);  /* G#m7 is preferred */
  269.     learn_chord ("Absus", N, N, 1, 1, 2, 4, 1);
  270.     learn_chord ("Ab+", N, N, 2, 1, 1, 0, 1);
  271.     learn_chord ("Abdim", N, N, 0, 1, 0, 1, 1);         /* G#dim is preferred */
  272.     learn_chord ("Abmaj7", N, N, 1, 1, 1, 3, 1);
  273.  
  274.     learn_chord ("A", N, 0, 2, 2, 2, 0, 1);
  275.     learn_chord ("Am", N, 0, 2, 2, 1, 0, 1);
  276.     learn_chord ("A7", N, 0, 2, 0, 2, 0, 1);
  277.     learn_chord ("Am7", N, 0, 2, 2, 1, 3, 1);
  278.     learn_chord ("Asus", N, N, 2, 2, 3, 0, 1);
  279.     learn_chord ("A+", N, 0, 3, 2, 2, 1, 1);
  280.     learn_chord ("Adim", N, N, 1, 2, 1, 2, 1);
  281.     learn_chord ("Amaj7", N, 0, 2, 1, 2, 0, 1);
  282.  
  283.     learn_chord ("A#", N, 1, 3, 3, 3, 1, 1);    /* Bb is preferred */
  284.     learn_chord ("A#m", N, 1, 3, 3, 2, 1, 1);   /* Bbm is preferred */
  285.     learn_chord ("A#7", N, N, 1, 1, 1, 2, 3);   /* Bb7 is preferred */
  286.     learn_chord ("A#m7", N, 1, 3, 1, 2, 1, 1);  /* Bbm7 is preferred */
  287.     learn_chord ("A#sus", N, N, 3, 3, 4, 1, 1);         /* Bbsus is preferred */
  288.     learn_chord ("A#+", N, N, 0, 3, 3, 2, 1);   /* Bb+ is preferred */
  289.     learn_chord ("A#dim", N, N, 2, 3, 2, 3, 1);         /* Bbdim is preferred */
  290.     learn_chord ("A#maj7", N, 1, 3, 2, 3, N, 1);        /* Bbmaj7 is preferred */
  291.  
  292.     learn_chord ("Bb", N, 1, 3, 3, 3, 1, 1);
  293.     learn_chord ("Bbm", N, 1, 3, 3, 2, 1, 1);
  294.     learn_chord ("Bb7", N, N, 1, 1, 1, 2, 3);
  295.     learn_chord ("Bbm7", N, 1, 3, 1, 2, 1, 1);
  296.     learn_chord ("Bbsus", N, N, 3, 3, 4, 1, 1);
  297.     learn_chord ("Bb+", N, N, 0, 3, 3, 2, 1);
  298.     learn_chord ("Bbdim", N, N, 2, 3, 2, 3, 1);
  299.     learn_chord ("Bbmaj7", N, 1, 3, 2, 3, N, 1);
  300.  
  301.     learn_chord ("B", N, 2, 4, 4, 4, 2, 1);
  302.     learn_chord ("Bm", N, 2, 4, 4, 3, 2, 1);
  303.     learn_chord ("B7", 0, 2, 1, 2, 0, 2, 1);
  304.     learn_chord ("Bm7", N, 1, 3, 1, 2, 1, 2);
  305.     learn_chord ("Bsus", N, N, 3, 3, 4, 1, 2);
  306.     learn_chord ("B+", N, N, 1, 0, 0, 4, 1);
  307.     learn_chord ("Bdim", N, N, 0, 1, 0, 1, 1);
  308.     learn_chord ("Bmaj7", N, 2, 4, 3, 4, N, 1);
  309.  
  310.     learn_chord ("C", N, 3, 2, 0, 1, 0, 1);
  311.     learn_chord ("Cm", N, 1, 3, 3, 2, 1, 3);
  312.     learn_chord ("C7", 0, 3, 2, 3, 1, 0, 1);
  313.     learn_chord ("Cm7", N, 1, 3, 1, 2, 1, 3);
  314.     learn_chord ("Csus", N, N, 3, 0, 1, 3, 1);
  315.     learn_chord ("C+", N, N, 2, 1, 1, 0, 1);
  316.     learn_chord ("Cdim", N, N, 1, 2, 1, 2, 1);
  317.     learn_chord ("Cmaj7", N, 3, 2, 0, 0, 0, 1);
  318.  
  319.     learn_chord ("C#", N, N, 3, 1, 2, 1, 1);    /* Db is preferred */
  320.     learn_chord ("C#m", N, N, 2, 1, 2, 0, 1);
  321.     learn_chord ("C#7", N, N, 3, 4, 2, 4, 1);   /* Db7 is preferred */
  322.     learn_chord ("C#m7", N, N, 2, 4, 2, 4, 1);
  323.     learn_chord ("C#sus", N, N, 3, 3, 4, 1, 4);         /* Dbsus is preferred */
  324.     learn_chord ("C#+", N, N, 3, 2, 2, 1, 1);   /* Db+ is preferred */
  325.     learn_chord ("C#dim", N, N, 2, 3, 2, 3, 1);
  326.     learn_chord ("C#maj7", N, 4, 3, 1, 1, 1, 1);        /* Dbmaj7 is preferred */
  327.  
  328.     learn_chord ("Db", N, N, 3, 1, 2, 1, 1);
  329.     learn_chord ("Dbm", N, N, 2, 1, 2, 0, 1);   /* C#m is preferred */
  330.     learn_chord ("Db7", N, N, 3, 4, 2, 4, 1);
  331.     learn_chord ("Dbm7", N, N, 2, 4, 2, 4, 1);  /* C#m7 is prefered */
  332.     learn_chord ("Dbsus", N, N, 3, 3, 4, 1, 4);
  333.     learn_chord ("Db+", N, N, 3, 2, 2, 1, 1);   /* Db+ is preferred */
  334.     learn_chord ("Dbdim", N, N, 2, 3, 2, 3, 1);
  335.     learn_chord ("Dbmaj7", N, 4, 3, 1, 1, 1, 1);
  336.  
  337.     learn_chord ("D", N, N, 0, 2, 3, 2, 1);
  338.     learn_chord ("Dm", N, N, 0, 2, 3, 1, 1);
  339.     learn_chord ("D7", N, N, 0, 2, 1, 2, 1);
  340.     learn_chord ("Dm7", N, N, 0, 2, 1, 1, 1);
  341.     learn_chord ("Dsus", N, N, 0, 2, 3, 3, 1);
  342.     learn_chord ("D+", N, N, 0, 3, 3, 2, 1);
  343.     learn_chord ("Ddim", N, N, 0, 1, 0, 1, 1);
  344.     learn_chord ("Dmaj7", N, N, 0, 2, 2, 2, 1);
  345.  
  346.     learn_chord ("D#", N, N, 3, 1, 2, 1, 3);    /* Eb is preferred */
  347.     learn_chord ("D#m", N, N, 4, 3, 4, 2, 1);   /* Ebm is preferred */
  348.     learn_chord ("D#7", N, N, 1, 3, 2, 3, 1);   /* Eb7 is preferred */
  349.     learn_chord ("D#m7", N, N, 1, 3, 2, 2, 1);  /* Ebm7 is preferred */
  350.     learn_chord ("D#sus", N, N, 1, 3, 4, 4, 1);         /* Ebsus is preferred */
  351.     learn_chord ("D#+", N, N, 1, 0, 0, 4, 1);   /* Eb+ is preferred */
  352.     learn_chord ("D#dim", N, N, 1, 2, 1, 2, 1);
  353.     learn_chord ("D#maj7", N, N, 1, 3, 3, 3, 1);        /* Ebmaj7 is preferred */
  354.  
  355.     learn_chord ("Eb", N, N, 3, 1, 2, 1, 3);
  356.     learn_chord ("Ebm", N, N, 4, 3, 4, 2, 1);
  357.     learn_chord ("Eb7", N, N, 1, 3, 2, 3, 1);
  358.     learn_chord ("Ebm7", N, N, 1, 3, 2, 2, 1);
  359.     learn_chord ("Ebsus", N, N, 1, 3, 4, 4, 1);
  360.     learn_chord ("Eb+", N, N, 1, 0, 0, 4, 1);
  361.     learn_chord ("Ebdim", N, N, 1, 2, 1, 2, 1);         /* D#dim is preferred */
  362.     learn_chord ("Ebmaj7", N, N, 1, 3, 3, 3, 1);
  363.  
  364.     learn_chord ("E", 0, 2, 2, 1, 0, 0, 1);
  365.     learn_chord ("Em", 0, 2, 2, 0, 0, 0, 1);
  366.     learn_chord ("E7", 0, 2, 2, 1, 3, 0, 1);
  367.     learn_chord ("Em7", 0, 2, 2, 0, 3, 0, 1);
  368.     learn_chord ("Esus", 0, 2, 2, 2, 0, 0, 1);
  369.     learn_chord ("E+", N, N, 2, 1, 1, 0, 1);
  370.     learn_chord ("Edim", N, N, 2, 3, 2, 3, 1);
  371.     learn_chord ("Emaj7", 0, 2, 1, 1, 0, N, 1);
  372.  
  373.     learn_chord ("F", 1, 3, 3, 2, 1, 1, 1);
  374.     learn_chord ("Fm", 1, 3, 3, 1, 1, 1, 1);
  375.     learn_chord ("F7", 1, 3, 1, 2, 1, 1, 1);
  376.     learn_chord ("Fm7", 1, 3, 1, 1, 1, 1, 1);
  377.     learn_chord ("Fsus", N, N, 3, 3, 1, 1, 1);
  378.     learn_chord ("F+", N, N, 3, 2, 2, 1, 1);
  379.     learn_chord ("Fdim", N, N, 0, 1, 0, 1, 1);
  380.     learn_chord ("Fmaj7", N, 3, 3, 2, 1, 0, 1);
  381.  
  382.     learn_chord ("F#", 2, 4, 4, 3, 2, 2, 1);    /* or Gb */
  383.     learn_chord ("F#m", 2, 4, 4, 2, 2, 2, 1);   /* or Gbm */
  384.     learn_chord ("F#7", N, N, 4, 3, 2, 0, 1);   /* or Gb7 */
  385.     learn_chord ("F#m7", N, N, 2, 2, 2, 2, 1);  /* or Gbm7 */
  386.     learn_chord ("F#sus", N, N, 4, 4, 2, 2, 1);         /* or Gbsus */
  387.     learn_chord ("F#+", N, N, 4, 3, 3, 2, 1);   /* or Gb+ */
  388.     learn_chord ("F#dim", N, N, 1, 2, 1, 2, 1);         /* or Gbdim */
  389.     learn_chord ("F#maj7", N, N, 4, 3, 2, 1, 1);        /* Gbdim is preferred */
  390.  
  391.     learn_chord ("Gb", 2, 4, 4, 3, 2, 2, 1);    /* or F# */
  392.     learn_chord ("Gbm", 2, 4, 4, 2, 2, 2, 1);   /* or F#m */
  393.     learn_chord ("Gb7", N, N, 4, 3, 2, 0, 1);   /* or F#7 */
  394.     learn_chord ("Gbm7", N, N, 2, 2, 2, 2, 1);  /* or F#m7 */
  395.     learn_chord ("Gbsus", N, N, 4, 4, 2, 2, 1);         /* or F#sus */
  396.     learn_chord ("Gb+", N, N, 4, 3, 3, 2, 1);   /* or F#+ */
  397.     learn_chord ("Gbdim", N, N, 1, 2, 1, 2, 1);         /* or F#dim */
  398.     learn_chord ("Gbmaj7", N, N, 4, 3, 2, 1, 1);
  399.  
  400.     learn_chord ("G", 3, 2, 0, 0, 0, 3, 1);
  401.     learn_chord ("Gm", 1, 3, 3, 1, 1, 1, 3);
  402.     learn_chord ("G7", 3, 2, 0, 0, 0, 1, 1);
  403.     learn_chord ("Gm7", 1, 3, 1, 1, 1, 1, 3);
  404.     learn_chord ("Gsus", N, N, 0, 0, 1, 3, 1);
  405.     learn_chord ("G+", N, N, 1, 0, 0, 4, 1);
  406.     learn_chord ("Gdim", N, N, 2, 3, 2, 3, 1);
  407.     learn_chord ("Gmaj7", N, N, 1, 2, 3, 4, 2);
  408.  
  409.     learn_chord ("G#", 1, 3, 3, 2, 1, 1, 4);    /* Ab is preferred */
  410.     learn_chord ("G#m", 1, 3, 3, 1, 1, 1, 4);
  411.     learn_chord ("G#7", N, N, 1, 1, 1, 2, 1);   /* Ab7 is preferred */
  412.     learn_chord ("G#m7", N, N, 1, 1, 1, 1, 4);
  413.     learn_chord ("G#sus", N, N, 1, 1, 2, 4, 1);         /* Absus is preferred */
  414.     learn_chord ("G#+", N, N, 2, 1, 1, 0, 1);   /* Ab+ is preferred */
  415.     learn_chord ("G#dim", N, N, 0, 1, 0, 1, 1);
  416.     learn_chord ("G#maj7", N, N, 1, 1, 1, 3, 1);        /* Abmaj7 is preferred */
  417. #undef N
  418. #undef X
  419. }
  420.  
  421. is_chord_known (char *chord) {
  422.     int i;
  423.  
  424.     for (i = 0; i < nb_known_chord; i++)
  425.         if (!strcmp (chord, known_chords[i].chord_name))
  426.             return (i);
  427.     return (-1);
  428. }
  429.  
  430. dump_fret (fretnum) {
  431.     if (fretnum == FRET_NONE)
  432.         printf ("  %2s", FRET_NONE_STR);
  433.     else if (fretnum == FRET_X)
  434.         printf ("  %2s", FRET_X_STR);
  435.     else
  436.         printf ("  %2d", fretnum);
  437. }
  438.  
  439. dump_chords () {
  440.     int i;
  441.  
  442.     printf ("#Chord         pos 1st 2nd 3rd 4th 5th 6th\n");
  443.     for (i = 0; i < nb_known_chord; i++) {
  444.         printf ("{define %s      %2d",
  445.                 known_chords[i].chord_name, known_chords[i].displ);
  446.         dump_fret (known_chords[i].s6);
  447.         dump_fret (known_chords[i].s5);
  448.         dump_fret (known_chords[i].s4);
  449.         dump_fret (known_chords[i].s3);
  450.         dump_fret (known_chords[i].s2);
  451.         dump_fret (known_chords[i].s1);
  452.         printf ("}\n");
  453.     }
  454. }
  455.  
  456.